Method and related system of dynamic compiler resolution

ABSTRACT

A method and related system of dynamic compiler resolution. Some of the illustrative embodiments are a computer-implemented method comprising compiling a source file containing an application program (the compiling creates a destination file containing a compiled version of the application program), and inserting in the compiled version of the application program a series of commands that (when executed at run time of the application program) generate an optimized code portion using a value available at run time.

CROSS-REFERENCE TO RELATED APPLICATIONS

This application claims the benefit of European Patent Application No.04291918.3, filed Jul. 27, 2004, incorporated by reference herein as ifreproduced in full below. This application is related to co-pending andcommonly assigned application Ser. No. ______ [atty. docket TI-38588(1962-22900)] entitled “Method And System Of Adaptive CompilerResolution.”

BACKGROUND OF THE INVENTION

1. Technical Field of the Invention

Embodiments of the present invention relate to compilers and creation ofoptimized executable code.

2. Background Information

A compiler is a software program that takes a source file containing aprogram in a particular form, and converts the program to another form.In some cases, the compiler starts with a human-readable source codefile (e.g. a program written in JAVA™ or C++) and converts or compilesto a binary file that may be directly executable or that may requireinterpretation or further compiling.

Compilers come in several varieties, such as static compilers (sometimesreferred to as “ahead-in-time” compilers) or dynamic compilers(sometimes referred to as “just-in-time” compilers). Static compilerscomplete their work on the source file before the program is executed.Dynamic compilers, by contrast, compile the source file during executionof the program embodied in the source file. Both static and dynamiccompilers also may perform optimization as part of the compilingprocessing, possibly to reduce execution time.

Static compilers perform some optimizations, such as inlining ofmethods, but in many cases optimization requires the knowledge of valuesof runtime parameters which are not known when static compiling isperformed. Dynamic compilers thus have the advantage of having availablethe values of runtime parameters, and thus may make optimizations basedon those parameters, but gain realized by optimization performed bydynamic compilers is offset by the fact the compiler too is running andsharing time on the processor, thus slowing the overall execution of theapplication program.

SUMMARY

The problems noted above are solved in large part by a method andrelated system of dynamic compiler resolution. Some of the illustrativeembodiments are a computer-implemented method comprising compiling asource file containing an application program (the compiling creates adestination file containing a compiled version of the applicationprogram), and inserting in the compiled version of the applicationprogram a series of commands that (when executed at run time of theapplication program) generate an optimized code portion using a valueavailable at run time.

Other illustrative embodiments are a computer-readable medium storing acompiler program that performs a method comprising compiling source codeof an application program to create a compiled version of theapplication program, and inserting in the compiled version of theapplication program a series of commands that, when executed at run timeof the application program, generate optimized code using a valueavailable at run time.

Yet still other illustrative embodiments are a system comprising amemory (wherein the memory contains a source file of an program), and afirst processor coupled to the memory. The first processor is configuredto compile the program of the source file to create a compiled program,and the processor is configured to insert in the compiled program aseries of commands that (when executed at run time) generate anoptimized code portion using a value available at run time.

NOTATION AND NOMENCLATURE

Certain terms are used throughout the following description and claimsto refer to particular system components. As one skilled in the art willappreciate, semiconductor companies may refer to a component bydifferent names. This document does not intend to distinguish betweencomponents that differ in name but not function. In the followingdiscussion and in the claims, the terms “including” and “comprising” areused in an open-ended fashion, and thus should be interpreted to mean“including, but not limited to . . . ”. Also, the term “couple” or“couples” is intended to mean either an indirect or direct connection.Thus, if a first device couples to a second device, that connection maybe through a direct connection, or through an indirect connection viaother devices and connections.

BRIEF DESCRIPTION OF THE DRAWINGS

For a more detailed description of the preferred embodiments of thepresent invention, reference will now be made to the accompanyingdrawings, wherein:

FIG. 1 shows a diagram of a system in accordance with embodiments of theinvention;

FIG. 2 illustrates graphically operation of a compiler and applicationprogram in accordance with embodiments of the invention;

FIG. 3 illustrates a flow diagram implemented partially within acompiler and partially within an application program compiled by thecompiler, in accordance with embodiments of the invention;

FIG. 4 illustrates graphically operation of a compiler and applicationprogram in accordance with alternative embodiments of the invention;

FIG. 5 illustrates a flow diagram implemented partially within acompiler and partially within an application program compiled by thecompiler, in accordance with alternative embodiments of the invention;and

FIG. 6 illustrates a system in accordance with at least some embodimentsof the invention.

DETAILED DESCRIPTION OF THE PREFERRED EMBODIMENTS

The following discussion is directed to various embodiments of theinvention. Although one or more of these embodiments may be preferred,the embodiments disclosed should not be interpreted, or otherwise used,as limiting the scope of the disclosure, unless otherwise specified. Inaddition, one skilled in the art will understand that the followingdescription has broad application, and the discussion of any embodimentsis meant only to be exemplary of those embodiments, and not intended tointimate that the scope of the disclosure is limited to thoseembodiments.

Moreover, the various embodiments were developed in the context ofprocessors executing Java™ bytecodes, and thus the description isrelated to the developmental context; however, the various embodimentsfind application outside the Java environment, such as Microsoft's“.NET” (pronounced “dot net”) framework or in programs written in C andC++, and thus the description in relation to a Java environment shouldnot be construed as a limitation as to the breadth of the disclosure.

Java is a programming language that, at the source code level, issimilar to object oriented programming languages such as C++. Javalanguage source code is compiled into an intermediate representationbased on a plurality hardware platform independent “bytecodes” thatdefine specific tasks. An “opcode” is a single member of the groupbytecodes. In some implementations, the bytecodes are further compiledto machine language for a particular processor. Some processors,however, are designed to execute some or all the Java bytecodesdirectly.

FIG. 1 shows a system 100 in accordance with embodiments of theinvention. As shown, the system may comprise at least two processors 102and 104. Processor 102 may be referred to for purposes of thisdisclosure as a Java Stack Machine (“JSM”) and processor 104 may bereferred to as a Main Processor Unit (“MPU”). System 100 may alsocomprise memory 106 coupled to both the JSM 102 and MPU 104. At least aportion of the memory 106 may be shared by both processors, and ifdesired, other portions of the memory 106 may be designated as privateto one processor or the other. System 100 also comprises a Java VirtualMachine (“JVM”) 108, compiler 110, and a display 114. The JVM 108 maycomprise a class loader, bytecode verifier, garbage collector, and abytecode interpreter loop to interpret the bytecodes that are notexecuted on the JSM processor 102. Other components (not specificallyshown) may be used as desired for various applications.

Bytecodes 112 may be provided to the JVM 108, possibly compiled bycompiler 110, and provided to the JSM 102 and/or MPU 104 for execution.In accordance with some embodiments of the invention, the JSM 102 mayexecute at least some Java bytecodes directly. When appropriate,however, the JVM 108 may also request the MPU 104 to execute one or moreJava bytecodes not executed or executable by the JSM 102. In addition toexecuting compiled Java bytecodes, the MPU 104 also may execute non-Javainstructions. The MPU 104 may thus also host an operating system (“O/S”)(not specifically shown) which performs various functions such as systemmemory management, system task management that schedules the softwareaspects of the JVM 108 and most or all other native tasks running on thesystem, management of the display 114, and receiving input from inputdevices (not specifically shown). Java code, whether executed on the JSM102 or MPU 104, may be used to perform any one of a variety ofapplications such as multimedia, games or web based applications in thesystem 100, while non-Java code, which may comprise the O/S and othernative applications, may still run on the system on the MPU 104.

FIG. 2 graphically illustrates operation of a compiler and anapplication program in accordance with embodiments of the invention. Inparticular, FIG. 2 illustrates a source file 200, which source filecontains an application program comprising, at least in part, a method202. The method 202 could be, for example, a subroutine of the largerapplication program. The application program of the source file 200 iscompiled (such as by compiler 110 of FIG. 1), and the results of thecompiling are placed in a destination file 204. In some embodiments thesource file is human-readable source code, such as written in Java orC++. In other embodiments, the application program of the source file200 may be code that is already at least partially compiled, such as aJava language application program compiled to bytecodes. The results ofthe compiling may likewise take many forms. The compiled version of theapplication program may be executable directly or indirectly by aprocessor. For example, Java language human-readable source code may becompiled to bytecodes which are directly executable by some processors(such as JSM 102), or which need further compiling to platform dependentinstruction sets for processors that do not directly execute bytecodes(such as MPU 104).

Regardless of the form of the source and destination files, inaccordance with embodiments of the invention the compiler inserts intothe compiled version of the application program in the destination filea series of commands 206. The terms “series of commands” are used todistinguish the original method; however, the series of commands may beanother method of the application program, albeit drafted by thecompiler rather than the author of the source code. The series ofcommands 206 are generated by the compiler such that when theapplication program is actually executed, and in particular when theseries of commands 206 as part of the application program are executed,the series of commands determine a value of a parameter which isavailable at runtime (and which may not have been available in a staticcompiling), and the series of commands generate an optimized version ofthe method based on the value. For example, an indirect reference bothin the human-readable source code file and the compiled version of theapplication program may be resolved at run time, and the illustrativemethod may be optimized using the resolved value.

In accordance with at least some embodiments, the series of commands maybe executed multiple times, and each time generate the optimized versionof the method that is thereafter executed. In alternative embodiments,however, the series of commands 206 are further configured to replacethemselves with the optimized method 208, thus creating a modifieddestination file 210. In these embodiments, the series of commandsexecute one time, to determine the value of interest, generate anoptimized method based on that value, and overwrite the series ofcommands with the optimized method.

FIG. 3 illustrates a flow diagram that is implemented partially within acompiler, and partially within an application program compiled by thecompiler. More particularly, FIG. 3 illustrates the operation of thecompiler and modified application program as discussed with respect toFIG. 2. The process starts (block 300), and in addition to other dutiesof the compiler, a determination is made as to whether a method (e.g.,method 202 of FIG. 2) can be optimized based on a value available at runtime (block 304). If not, a determination is made as to whether othermethods exist in the application program for possible optimization(block 312). If there are no further methods, the process ends (block316). If there are further methods, however, the process starts anewwith the determination of whether the next method can be optimized basedon a value available at run time (again block 304).

Still referring to FIG. 3, if a method can be optimized based on a runtime value, the compiler inserts a series of commands into the compiledversion of the application program for generating, at run time of theapplication program, an optimized version of the method (block 308).Thereafter, a determination is made as to whether more methods exist forpossible run time optimization (block 312). The illustrative steps ofFIG. 3 discussed to this point are preferably implemented within acompiler. The remaining steps (blocks 320 and 324) are preferablyimplemented as part of the application program previously (wholly orpartially) compiled by the compiler.

The series of commands, executed as part of the application program andnot the compiler program, generate the optimized method using the valueavailable at run time (block 320). Moreover, and in at least someembodiments, the series of commands overwrite themselves with theoptimized method (block 324). In some embodiments the series of commandsare overwritten only in the copy of the application program stored involatile memory (e.g., RAM), but not in the compiled version of theapplication stored on a non-volatile memory (e.g., a disk drive). If thevalue available at run time is expected to the same each and every timethe application program thereafter runs, then the series of commands mayalso be overwritten on non-volatile memory device.

The discussion of the various embodiments to this point has assumed thatsufficient optimization of the overall application program may beachieved with an optimized method for only one run time value, and thisassumption is valid in many situations. In alternative embodiments,however, an illustrative method may be optimized based on several valuesavailable at run time, and further still, the values for which themethod is optimized may change over the course of the execution of theapplication program. FIG. 4 illustrates operation of a compiler and anapplication program in accordance with alternative embodiments of theinvention. In particular, FIG. 4 illustrates a source file 400, whichsource file contains an application program comprising, at least inpart, a method 402. The method 402 could be, for example, a subroutineof the larger application program. The application program of the sourcefile 400 is compiled (such as by compiler 110 of FIG. 1), and theresults of the compiling are placed in a destination file 404. Much likethe embodiments discussed with respect to FIG. 2, the source file anddestination may take many forms.

In accordance with these alternative embodiments, the compiler insertsinto the compiled version of the destination file a series of commands406. The series of commands 406 are generated by the compiler such thatwhen the application program is actually executed, and in particularwhen the series of commands 406 as part of the application program areexecuted, the series of commands perform several actions. In particular,the series of commands may implement dynamic monitoring code 408(discussed more fully below), and may also determine a value or valuesof parameters which are available at run time (and which may not havebeen available in a static compiling). Further, the series of commands406 also generate optimized versions of the method based on the value orvalues determined by the dynamic monitoring code 408.

In accordance with these alternative embodiments, the dynamic monitoringcode 408 runs as part of the application program, and determines whichrun time values are predominantly used by the method 410 (which ismethod 402 compiled and optimized (to the extent possible) for generaldata). The terms “dynamic monitoring code” are used to distinguish theoriginal method; however, the dynamic monitoring code may be anothermethod of the application program, albeit drafted by the compiler ratherthan the author of the source code. Stated otherwise, the dynamicmonitoring code 408 (part of the series of commands written by thecompiler) monitors a plurality of executions of the method 410, anddetermines which run time values are predominantly used. Based on thisdetermination, the series of commands 406 then generate a plurality ofoptimized versions of the method 402/410 (e.g., first optimized method412 and a second optimized method 414), one each for each of thepredominantly used values, and writes the optimized methods to themodified destination file 416. Although not specifically shown in FIG.4, the series of commands also write “glue” code that directs programflow to the proper optimized method based on the run time value, or ifthere is not an optimized method for the particular run time value, tothe method 410 for general data.

In accordance with some embodiments, when a plurality of predominantlyused run time values has been determined, the optimized methodsoverwrite the dynamic monitoring code in the modified destination file.In alternative embodiments, however, the dynamic monitoring coderemains, and in the event the predominantly used run time values changeover the course of executing the application program, the dynamicmonitor code 408 generates new optimized methods that either replace oraugment the previously generated optimized methods.

FIG. 5 illustrates a flow diagram that is implemented partially within acompiler, and partially within an application program compiled by thecompiler. More particularly, FIG. 5 illustrates the operation of thecompiler and modified application program as discussed with respect toFIG. 4. The process starts (block 500), and in addition to other dutiesof the compiler, a determination is made as to whether the method (e.g.,method 402 of FIG. 4) can be optimized based on a value available at runtime (block 502). If not, a determination is made as to whether othermethods exist in the application program for possible optimization(block 510). If there are no further methods, the process ends (block512). If there are further methods, however, the process starts anewwith the determination of whether the next method can be optimized basedon a value available at run time (again block 502).

Still referring to FIG. 5, if the method can be optimized based on a runtime value, the compiler inserts a series of commands for run timemonitoring of values into the compiled version of the applicationprogram (block 504). The compiler also inserts a series of commands forrun time optimization of the method (block 506), and further inserts acompiled version of the method optimized (to the extent possible) forgeneral data (block 508). Thereafter, a determination is made as towhether more methods exist for possible run time optimization (block510). The illustrative steps discussed to this point are preferablyimplemented within a compiler. The remaining steps are preferablyimplemented as part of the application program previously (wholly orpartially) compiled by the compiler.

The run time portion of the various embodiments start (block 516) withexecution of the application program, and the series of commands monitora plurality of executions of the method optimized for general data(block 518). Based on data obtained from the monitoring, a determinationis made as to whether there are any predominantly used values (block520). If there are no predominantly used values, the illustrative methodretreats to further monitoring (block 518). If there are predominantlyused values (again block 520), a determination is made as to whetheroptimized versions of the method have already been generated for thosevalues (block 522). If so, then the illustrative method retreats againto monitoring execution of the method optimized for general data (block518). If, on the other hand, the illustrative method has not generatedan optimized method for the predominantly used values, optimized methodsare generated and written to the modified destination file (block 524).In some embodiments, each method optimized for a particular value isretained, and further optimized methods added. In cases where storagespace in the modified destination file is limited, each time anoptimized method is generated it may overwrite other optimized versionsof the method. Further still, if storage space is an issue, the dynamicmonitor code may be overwritten. Stated otherwise, once one or morepredominantly used values are determined, the illustrative method may nolonger perform the dynamic monitoring.

System 100 may be implemented as a mobile cell phone such as that shownin FIG. 6. As shown, the mobile communication device includes anintegrated keypad 612 and display 614. The JSM processor 102 and MPUprocessor 104 and other components may be included in electronicspackage 610 connected to the keypad 612, display 414, and radiofrequency (“RF”) circuitry 416. The RF circuitry 416 may be connected toan antenna 418.

From the description provided herein, those skilled in the art arereadily able to combine software created as described with appropriategeneral purpose or a special purpose computer hardware to create acomputer system and/or computer subcomponents embodying aspects of theinvention, to create a computer system and/or computer subcomponents forcarrying out the method embodiments of the invention, and/or to create acomputer-readable medium storing a software program to implement methodaspects of the various embodiments. Moreover, the embodiments of theillustrative methods could be implemented together in a single program(with various subroutines), or split up into two or more programsexecuted on the processor.

While the various embodiments of the invention have been shown anddescribed, modifications thereof can be made by one skilled in the artwithout departing from the spirit and teachings of the invention. Theembodiments described herein are illustrative only, and are not intendedto be limiting. Many variations and modifications of the inventiondisclosed herein are possible and are within the scope of the invention.For example, compiling in accordance with embodiments of the inventionmay take place statically (ahead-in-time) or dynamically. Each and everyclaim is incorporated into the specification as an embodiment of thepresent invention.

1. A computer-implemented method comprising: compiling a source filecontaining an application program, the compiling creates a destinationfile containing a compiled version of the application program; andinserting in the compiled version of the application program a series ofcommands that, when executed at run time of the application program,generate an optimized code portion using a value available at run time.2. The computer-implemented method as defined in claim 1 whereincompiling further comprises compiling a source file containinghuman-readable source code of the application program.
 3. Thecomputer-implemented method as defined in claim 1 wherein compilingcreates the compiled version of the application program that isexecutable.
 4. The computer-implemented method as defined in claim 3wherein compiling creates the compiled version of the applicationprogram that is directly executable by a processor.
 5. Thecomputer-implemented method as defined in claim 3 wherein compilingcreates the compiled version of the application program executable on aprocessor by way of an interpreter.
 6. The computer-implemented methodas defined in claim 1 further comprising, after inserting, replacing theseries of commands with the optimized code portion.
 7. Thecomputer-implemented method as defined in claim 1 wherein the compilingand inserting take place prior to execution of the application program.8. The computer-implemented method as defined in claim 1 wherein thecompiling and inserting take place on a first portion of the applicationprogram while a second portion of the application program is executed.9. A computer-readable medium storing a compiler program that, whenexecuted by a processor, performs a method comprising: compiling sourcecode of an application program to create a compiled version of theapplication program; and inserting in the compiled version of theapplication program a series of commands that, when executed at run timeof the application program, generate optimized code using a valueavailable at run time.
 10. The computer-readable medium as defined inclaim 9 wherein compiling further comprises compiling to create anexecutable version of the application program.
 11. The computer-readablemedium as defined in claim 10 wherein compiling further comprisescompiling to create the compiled version of the application program thatis directly executable by a processor.
 12. The computer-readable mediumas defined in claim 10 wherein compiling further comprises compiling tocreate the compiled version of the application program that is platformindependent and executable on a processor by way of an interpreter. 13.The computer-readable medium as defined in claim 9 wherein compilingfurther comprises the source code of the application program that ishuman readable.
 14. The computer-readable medium as defined in claim 9wherein the method further comprises, after inserting, replacing theseries of commands in the compiled version of the application programwith the optimized code.
 15. The computer-readable medium as defined inclaim 9 wherein the compiling and inserting take place prior toexecution of the application program.
 16. The computer-readable mediumas defined in claim 9 wherein the compiling and inserting takes place ona first portion of the application program while a second portion of theapplication program is executed.
 17. A system comprising: a memory,wherein the memory contains a source file of an program; and a firstprocessor coupled to the memory; wherein the first processor isconfigured to compile the program of the source file to create acompiled program, and wherein the processor is configured to insert inthe compiled program a series of commands that, when executed at runtime, generate an optimized code portion using a value available at runtime.
 18. The system as defined in claim 17 wherein the source file inthe memory is a human readable source code file for the applicationprogram.
 19. The system as defined in claim 17 wherein the compiledversion of the program in the destination file is executable on theprocessor by way of an interpreter program.
 20. The system as defined inclaim 17 wherein the compiled version of the program in the destinationfile is directly executable on the processor.
 21. The system as definedin claim 17 further comprising: a second processor coupled to the memoryand the first processor; wherein the second processor is configured todirectly execute at least one command of the compiled program.
 22. Thesystem as defined in claim 17 further comprising wherein the firstprocessor is configured to create a first portion of the compiledprogram while a second portion of the compiled program executes on oneor both the first and second processors.
 23. The system as defined inclaim 17 further comprising wherein the first processor is configured tocreate the compiled program prior to execution of any portion of thecompiled program.